#include <cctype>
#include <regex>
#include <sstream>
#include <brpc/server.h>
#include <butil/logging.h>

#include "data_es.hpp"      // es数据管理封装
#include "data_redis.hpp"   // redis数据管理封装
#include "mysql_user.hpp"   // mysql数据管理封装
#include "mysql_outbox.hpp" // outbox 事件记录封装
#include "etcd.hpp"         // 服务注册封装
#include "logger.hpp"       // 日志模块封装
#include "channel.hpp"      // 信道管理模块
#include "utils.hpp"        // 基础工具接口
#include "password.hpp"     // 加密模块

#include "user-odb.hxx"
#include "user.hxx"

#include "base.pb.h"        // protobuf框架代码
#include "user.pb.h"        // protobuf框架代码
#include "file.pb.h"        // protobuf框架代码

#include "user_outbox_dispatcher.hpp"  // outbox 事件分发器

namespace suye
{
class UserServiceImpl : public suye::UserService {
public:
    UserServiceImpl(const std::shared_ptr<elasticlient::Client>& es_client,
        const std::shared_ptr<odb::core::database>& mysql_client,
        const std::shared_ptr<sw::redis::Redis>& redis_client,
        const ServiceManager::ptr& channel_manager,
        const std::string& file_service_name) 
        : _es_user(std::make_shared<ESUser>(es_client))
        , _mysql_user(std::make_shared<UserTable>(mysql_client))
        , _mysql_outbox(std::make_shared<OutboxTable>(mysql_client))
        , _redis_session(std::make_shared<Session>(redis_client))
        , _redis_status(std::make_shared<Status>(redis_client))
        , _redis_codes(std::make_shared<Codes>(redis_client))
        , _file_service_name(file_service_name)
        , _sm_channels(channel_manager) 
    {
        _es_user->createIndex();
    }

    ~UserServiceImpl() {}

    bool nickname_check(const std::string& nickname) {
        return (nickname.size() >= 3 && nickname.size() <= 18);
    }

    bool password_check(const std::string& password)
    {
        if (password.size() < 6 || password.size() > 15) {
            LOG_ERROR("密码长度不合法！{}-{}", password, password.size());
            return false;
        }
        for (char c: password) {
            if (!std::isalnum(c))  return false;
        }
        return true;  
    }

    bool phone_check(const std::string& phone)
    {
        if (phone.size() != 11) return false;
        if (phone[0] != '1') return false;
        char secondChar = phone[1];
        if (secondChar < '3' || secondChar > '9') return false;
        for (size_t i = 2; i < phone.size(); ++i) {
            if (!std::isdigit(phone[i]))  return false;
        }
        return true;
    }
    
    virtual void UserRegister(::google::protobuf::RpcController* controller,
                       const ::suye::UserRegisterReq* request,
                       ::suye::UserRegisterRsp* response,
                       ::google::protobuf::Closure* done)
    {
        LOG_DEBUG("收到用户注册请求！");
        brpc::ClosureGuard rpc_guard(done);

        // 定义一个错误处理函数，当出错的时候被调用
        auto err_response = [this, response](const std::string& rid, 
            const std::string& errmsg) -> void {
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
                return;
            };
        // 1. 从请求中取出昵称和密码
        std::string nickname = request->nickname();
        std::string password = request->password();

        // 2. 检查昵称是否合法（长度限制 3~15 之间）
        bool res = nickname_check(nickname);
        if (res == false) {
            LOG_ERROR("用户名格式不合法！- {}", nickname);
            return err_response(request->request_id(), "用户名格式不合法！");
        }

        // 3. 检查密码是否合法（只能包含字母，数字，长度限制 6~15 之间）
        res = password_check(password);
        if (res == false) {
            LOG_ERROR("密码格式不合法！- {}", password);
            return err_response(request->request_id(), "密码格式不合法！");
        }

        // 4. 根据昵称在数据库进行判断是否昵称已存在
        auto user = _mysql_user->select_by_nickname(nickname);
        if (user) {
            LOG_ERROR("用户名被占用 - {}！", nickname);
            return err_response(request->request_id(), "用户名被占用！");
        }

        // 5. 加密密码
        std::string encrypted_password = PassworldHasher::encryptPassword(password);
        LOG_DEBUG("密码加密成功，原长度: {}, 加密后长度: {}", 
            password.length(), encrypted_password.length());

        // 6. 向数据库新增数据，并记录 Outbox 事件
        std::string uid = uuid();
        user = std::make_shared<User>(uid, nickname, encrypted_password);
        std::ostringstream created_payload;
        created_payload << "{\"user_id\":\"" << uid << "\",\"nickname\":\"" << nickname << "\",\"source\":\"username\"}";
        auto create_event = std::make_shared<OutboxEvent>(
            uuid(),
            "user",
            uid,
            "USER_CREATED",
            created_payload.str());

        res = _mysql_user->insert(user, [this, create_event]() {
            return _mysql_outbox->record_event(create_event);
        });
        if (res == false) {
            LOG_ERROR("Mysql数据库新增用户数据失败！");
            return err_response(request->request_id(), "Mysql数据库新增用户数据失败！");
        }

        // 7. 向 ES 服务器中新增用户信息
        res = _es_user->appendData(uid, "", nickname, "", "");
        if (res == false) {
            LOG_ERROR("ES搜索引擎新增用户数据失败！");
            return err_response(request->request_id(), "ES搜索引擎新增用户数据失败！");
        }

        // 8. 组织响应，进行成功与否的响应即可
        response->set_request_id(request->request_id());
        response->set_success(true);
    }

    virtual void UserLogin(::google::protobuf::RpcController* controller,
                        const ::suye::UserLoginReq* request,
                        ::suye::UserLoginRsp* response,
                        ::google::protobuf::Closure* done)
    {
        LOG_DEBUG("收到用户登录请求！");
        brpc::ClosureGuard rpc_guard(done);

        // 定义一个错误处理函数，当出错的时候被调用
        auto err_response = [this, response](const std::string& rid, 
            const std::string& errmsg) -> void {
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
                return;
            };

        // 1. 从请求中取出昵称和密码
        std::string nickname = request->nickname();
        std::string password = request->password();

        // 2. 通过昵称获取用户信息，进行密码是否一致的判断
        auto user = _mysql_user->select_by_nickname(nickname);
        if (!user) {
            LOG_ERROR("用户名或密码错误！- {}", nickname);
            return err_response(request->request_id(), "用户名或密码错误！");
        }

        // 3. 验证密码
        std::string stored_hash = user->password();
        if (stored_hash.empty()) {
            LOG_ERROR("用户密码为空！- {}", nickname);
            return err_response(request->request_id(), "用户密码为空！");
        }

        bool password_valid = PassworldHasher::verifyPassword(password, stored_hash);
        if (password_valid == false) {
            LOG_ERROR("密码错误！- {}", nickname);
            return err_response(request->request_id(), "用户名或密码错误！");
        }

        // 4. 根据 redis 中的登录标记信息是否存在判断用户是否已经登录
        bool res = _redis_status->exists(user->user_id());
        if (res == true) {
            LOG_ERROR("用户已在其他地方登录！- {}", nickname);
            return err_response(request->request_id(), "用户已在其他地方登录！");
        }

        // 5. 构造会话 ID，生成会话键值对，向 redis 中添加会话信息以及登录标记信息
        std::string ssid = uuid();
        _redis_session->append(ssid, user->user_id());
        _redis_status->append(user->user_id());

        // 6. 组织响应，返回生成的会话 ID
        response->set_request_id(request->request_id());
        response->set_login_session_id(ssid);
        response->set_success(true);
    }

    virtual void GetPhoneVerifyCode(::google::protobuf::RpcController* controller,
                        const ::suye::PhoneVerifyCodeReq* request,
                        ::suye::PhoneVerifyCodeRsp* response,
                        ::google::protobuf::Closure* done)
    {
        LOG_DEBUG("收到短信验证码获取请求！");
        brpc::ClosureGuard rpc_guard(done);

        // 定义一个错误处理函数，当出错的时候被调用
        auto err_response = [this, response](const std::string& rid, 
            const std::string& errmsg) -> void {
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
                return;
            };

        // 1. 从请求中取出手机号码
        std::string phone = request->phone_number();

        // 2. 验证手机号码格式是否正确（必须以 1 开始，第二位 3~9 之间，后边 9 个数字字符）
        bool res = phone_check(phone);
        if (res == false) {
            LOG_ERROR("手机号码格式错误！- {}", phone);
            return err_response(request->request_id(), "手机号码格式错误！");
        } 

        /*由于资质需要企业验证的原因这部分被移除了，短信验证码无法发送到个人手机上
        * 3. 生成 4 位随机验证码 
        * 4. 基于短信平台 SDK 发送验证码
        */
        
        // 5. 构造验证码 ID，添加到 redis 验证码映射键值索引中
        std::string code_id = uuid();
        std::string code = vcode();
        _redis_codes->append(code_id, code);

        // 6. 组织响应，返回生成的验证码 ID
        response->set_request_id(request->request_id());
        response->set_success(true);
        response->set_verify_code_id(code_id);
        LOG_DEBUG("获取短信验证码处理完成！");
    }

    virtual void PhoneRegister(::google::protobuf::RpcController* controller,
                        const ::suye::PhoneRegisterReq* request,
                        ::suye::PhoneRegisterRsp* response,
                        ::google::protobuf::Closure* done)
    {
        LOG_DEBUG("收到手机号注册请求！");
        brpc::ClosureGuard rpc_guard(done);

        // 定义一个错误处理函数，当出错的时候被调用
        auto err_response = [this, response](const std::string& rid, 
            const std::string& errmsg) -> void {
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
                return;
            };

        // 1. 从请求中取出手机号码，验证码和验证码ID
        std::string phone = request->phone_number();
        std::string code = request->verify_code();
        std::string code_id = request->verify_code_id();

        // 2. 检查注册手机号码是否合法
        bool res = phone_check(phone);
        if (res == false) {
            LOG_ERROR("手机号码格式错误！- {}", phone);
            return err_response(request->request_id(), "手机号码格式错误!");
        } 

        // 3. 从 redis 数据库中进行验证码ID和验证码的一致性匹配
        auto vcode = _redis_codes->code(code_id);
        if (vcode != code) {
            LOG_ERROR("验证码错误！- {}-{}", code_id, code);
            return err_response(request->request_id(), "验证码错误！");
        }

        // 4. 通过数据库查询判断手机号是否已经注册过
        auto user = _mysql_user->select_by_phone(phone);
        if (user) {
            LOG_ERROR("该手机号已注册过用户！- {}", phone);
            return err_response(request->request_id(), "该手机号已注册过用户!");
        } 

        // 5. 向数据库新增用户信息，并记录 Outbox 事件
        std::string uid = uuid();
        user = std::make_shared<User>(uid, phone); 
        std::ostringstream created_payload;
        created_payload << "{\"user_id\":\"" << uid << "\",\"phone\":\"" << phone << "\",\"source\":\"phone\"}";
        auto create_event = std::make_shared<OutboxEvent>(
            uuid(),
            "user",
            uid,
            "USER_CREATED",
            created_payload.str());

        res = _mysql_user->insert(user, [this, create_event]() {
            return _mysql_outbox->record_event(create_event);
        });
        if (res == false) {
            LOG_ERROR("向数据库添加用户信息失败！- {}", phone);
            return err_response(request->request_id(), "向数据库添加用户信息失败!");
        }

        // 6. 向 ES 服务器中新增用户信息
        res = _es_user->appendData(uid, phone, uid, "", "");
        if (res == false) {
            LOG_ERROR("ES搜索引擎新增用户信息数据失败！");
            return err_response(request->request_id(), "ES搜索引擎新增用户信息数据失败！");
        }

        // 7. 组织响应，返回注册成功与否
        response->set_request_id(request->request_id());
        response->set_success(true);
    }

    virtual void PhoneLogin(::google::protobuf::RpcController* controller,
                        const ::suye::PhoneLoginReq* request,
                        ::suye::PhoneLoginRsp* response,
                        ::google::protobuf::Closure* done)
    {
        LOG_DEBUG("收到手机号登录请求！");
        brpc::ClosureGuard rpc_guard(done);

        // 定义一个错误处理函数，当出错的时候被调用
        auto err_response = [this, response](const std::string& rid, 
            const std::string& errmsg) -> void {
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
                return;
            };

        // 1. 从请求中取出手机号码和验证码 ID，以及验证码
        std::string phone = request->phone_number();
        std::string code = request->verify_code();
        std::string code_id = request->verify_code_id();

        // 2. 检查注册手机号码是否合法
        bool res = phone_check(phone);
        if (res == false) {
            LOG_ERROR("手机号码格式错误！- {}", phone);
            return err_response(request->request_id(), "手机号码格式错误!");
        } 

        // 3. 从 redis 数据库中进行验证码ID-验证码一致性匹配
        auto vcode = _redis_codes->code(code_id);
        if (vcode != code) {
            LOG_ERROR("验证码错误！- {}-{}", code_id, code);
            return err_response(request->request_id(), "验证码错误!");
        }
        _redis_codes->remove(code_id);

        // 4. 根据手机号从数据数据进行用户信息查询，判断用户是否存在
        auto user = _mysql_user->select_by_phone(phone);
        if (!user) {
            LOG_ERROR("该手机号未注册！- {}", phone);
            return err_response(request->request_id(), "该手机号未注册！");
        } 
        
        // 5. 根据 redis 中的登录标记信息是否存在判断用户是否已经登录
        std::string uid = user->user_id();
        res = _redis_status->exists(uid); 
        if (res == true) {
            LOG_ERROR("用户已在其他地方登录！- {}", phone);
            return err_response(request->request_id(), "用户已在其他地方登录!");
        }

        // 6. 构造会话 ID，生成会话键值对，向 redis 中添加会话信息以及登录标记信息
        std::string ssid = uuid();
        _redis_session->append(ssid, uid);
        _redis_status->append(uid);

        // 7. 组织响应，返回生成的对话 ID
        response->set_request_id(request->request_id());
        response->set_login_session_id(ssid);
        response->set_success(true);
    }

    //从这一步开始，用户登录之后才会进行的操作
    virtual void GetUserInfo(::google::protobuf::RpcController* controller,
                        const ::suye::GetUserInfoReq* request,
                        ::suye::GetUserInfoRsp* response,
                        ::google::protobuf::Closure* done)
    {
        LOG_DEBUG("收到获取单个用户信息请求！");
        brpc::ClosureGuard rpc_guard(done);

        // 定义一个错误处理函数，当出错的时候被调用
        auto err_response = [this, response](const std::string& rid, 
            const std::string& errmsg) -> void {
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
                return;
            };

        // 1. 从请求中取出用户 ID
        std::string uid = request->user_id();
        
        // 2. 通过用户 ID，从数据库中查询用户信息
        auto user = _mysql_user->select_by_uid(uid);
        if (!user) {
            LOG_ERROR("未找到用户信息！- {}", uid);
            return err_response(request->request_id(), "未找到用户信息!");
        }

        // 3. 根据用户信息中的头像 ID，从文件服务器获取头像文件数据，组织完整用户信息
        UserInfo* user_info = response->mutable_user_info();
        user_info->set_user_id(user->user_id());
        if (!user->nickname().empty()) user_info->set_nickname(user->nickname());
        if (!user->description().empty()) user_info->set_description(user->description());
        if (!user->phone().empty()) user_info->set_phone(user->phone());
        if (!user->avatar_id().empty()) {
            // 从信道管理对象中，获取到连接了文件管理子服务的channel
            auto channel = _sm_channels->Choose(_file_service_name);
            if (!channel) {
                LOG_ERROR("未找到文件管理子服务节点！- {}", _file_service_name);
                return err_response(request->request_id(), "未找到文件管理子服务节点!");
            }
            // 进行文件子服务的rpc请求，进行头像文件的下载
            suye::FileService_Stub stub(channel.get());
            suye::GetSingleFileReq req;
            req.set_request_id(request->request_id());
            req.set_file_id(user->avatar_id());

            suye::GetSingleFileRsp rsp;
            brpc::Controller cntl;
            stub.GetSingleFile(&cntl,& req,& rsp, nullptr);
            if (cntl.Failed() == true || rsp.success() == false) {
                LOG_ERROR("文件子服务调用失败！{}-{}", _file_service_name, cntl.ErrorText());
                return err_response(request->request_id(), "文件子服务调用失败!");
            }
            user_info->set_avatar(rsp.file_data().file_content());
        }   

        // 4. 组织响应，返回用户信息
        response->set_request_id(request->request_id());
        response->set_success(true);
    }

    virtual void GetMultiUserInfo(::google::protobuf::RpcController* controller,
                        const ::suye::GetMultiUserInfoReq* request,
                        ::suye::GetMultiUserInfoRsp* response,
                        ::google::protobuf::Closure* done)
    {
        LOG_DEBUG("收到批量用户信息获取请求！");
        brpc::ClosureGuard rpc_guard(done);

        // 定义一个错误处理函数，当出错的时候被调用
        auto err_response = [this, response](const std::string& rid, 
            const std::string& errmsg) -> void {
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
                return;
            };

        // 1. 从请求中取出用户 ID 列表
        std::vector<std::string> uid_lists;
        for (int i = 0; i < request->users_id_size(); i++) {
            uid_lists.push_back(request->users_id(i));
        }
        
        // 2. 从数据库进行批量用户信息查询
        auto users = _mysql_user->select_by_multi_users(uid_lists);
        if (users.size() != request->users_id_size()) {
            LOG_ERROR("从数据库查找的用户信息数量不一致！{}-{}", request->users_id_size(), users.size());
            return err_response(request->request_id(), "从数据库查找的用户信息数量不一致!");
        }

        // 3. 批量从文件管理子服务进行文件下载
        auto channel = _sm_channels->Choose(_file_service_name);
        if (!channel) {
            LOG_ERROR("未找到文件管理子服务节点！- {}", _file_service_name);
            return err_response(request->request_id(), "未找到文件管理子服务节点!");
        }
        // 进行文件子服务的rpc请求，进行头像文件的下载
        suye::FileService_Stub stub(channel.get());
        suye::GetMultiFileReq req;
        req.set_request_id(request->request_id());
        for (auto& user: users) {
            if (user.avatar_id().empty()) continue;
            req.add_file_id_list(user.avatar_id());
        }

        suye::GetMultiFileRsp rsp;
        brpc::Controller cntl;
        stub.GetMultiFile(&cntl,& req,& rsp, nullptr);
        if (cntl.Failed() == true || rsp.success() == false) {
            LOG_ERROR("文件子服务调用失败！{}-{}", _file_service_name, cntl.ErrorText());
            return err_response(request->request_id(), "文件子服务调用失败!");
        }
        
        // 4. 组织响应，返回用户信息
        response->set_request_id(request->request_id());
        response->set_success(true);
        for (auto& user: users) {
            auto user_map = response->mutable_users_info(); //本次请求要响应的用户信息map
            auto file_map = rsp.mutable_file_data();        //这是批量文件请求响应中的map 
            UserInfo user_info;
            user_info.set_user_id(user.user_id());
            user_info.set_nickname(user.nickname());
            user_info.set_description(user.description());
            user_info.set_phone(user.phone());
            user_info.set_avatar((*file_map)[user.avatar_id()].file_content());
            (*user_map)[user.user_id()] = user_info;
        }
    }

    virtual void SetUserAvatar(::google::protobuf::RpcController* controller,
                        const ::suye::SetUserAvatarReq* request,
                        ::suye::SetUserAvatarRsp* response,
                        ::google::protobuf::Closure* done)
    {
        LOG_DEBUG("收到用户头像设置请求！");
        brpc::ClosureGuard rpc_guard(done);

        // 定义一个错误处理函数，当出错的时候被调用
        auto err_response = [this, response](const std::string& rid, 
            const std::string& errmsg) -> void {
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
                return;
            };

        // 1. 从请求中取出用户 ID
        std::string uid = request->user_id();

        // 2. 从数据库通过用户 ID 进行用户信息查询，判断用户是否存在
        auto user = _mysql_user->select_by_uid(uid);
        if (!user) {
            LOG_ERROR("未找到用户信息！- {}", uid);
            return err_response(request->request_id(), "未找到用户信息!");
        }

        // 3. 上传头像文件到文件子服务
        auto channel = _sm_channels->Choose(_file_service_name);
        if (!channel) {
            LOG_ERROR("未找到文件管理子服务节点！- {}", _file_service_name);
            return err_response(request->request_id(), "未找到文件管理子服务节点!");
        }
        // 进行文件子服务的rpc请求，进行头像文件的下载
        suye::FileService_Stub stub(channel.get());
        suye::PutSingleFileReq req;
        req.set_request_id(request->request_id());
        req.mutable_file_data()->set_file_name("");
        req.mutable_file_data()->set_file_size(request->avatar().size());
        req.mutable_file_data()->set_file_content(request->avatar());

        suye::PutSingleFileRsp rsp;
        brpc::Controller cntl;
        stub.PutSingleFile(&cntl,& req,& rsp, nullptr);
        if (cntl.Failed() == true || rsp.success() == false) {
            LOG_ERROR("文件子服务调用失败！{}-{}", _file_service_name, cntl.ErrorText());
            return err_response(request->request_id(), "文件子服务调用失败!");
        }

        // 4. 将返回的头像文件 ID 更新到数据库中
        std::string avatar_id = rsp.file_info().file_id();
        user->avatar_id(avatar_id);
        bool res = _mysql_user->update(user);
        if (res == false) {
            LOG_ERROR("更新数据库用户头像ID失败！- {}", avatar_id);
            return err_response(request->request_id(), "更新数据库用户头像ID失败!");
        }

        // 5. 更新 ES 服务器中用户信息
        res = _es_user->appendData(user->user_id(), user->phone(), user->nickname(), user->description(), user->avatar_id());
        if (res == false) {
            LOG_ERROR("更新搜索引擎用户头像ID失败！- {}", avatar_id);
            return err_response(request->request_id(), "更新搜索引擎用户头像ID失败!");
        }

        // 6. 组织响应，返回更新成功与否
        response->set_request_id(request->request_id());
        response->set_success(true);
    }

    virtual void SetUserNickname(::google::protobuf::RpcController* controller,
                        const ::suye::SetUserNicknameReq* request,
                        ::suye::SetUserNicknameRsp* response,
                        ::google::protobuf::Closure* done)
    {
        LOG_DEBUG("收到用户昵称修改请求！");
        brpc::ClosureGuard rpc_guard(done);

        // 定义一个错误处理函数，当出错的时候被调用
        auto err_response = [this, response](const std::string& rid, 
            const std::string& errmsg) -> void {
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
                return;
            };

        // 1. 从请求中取出用户 ID 与新的昵称
        std::string uid = request->user_id();
        std::string new_nickname = request->nickname();

        // 2. 判断昵称格式是否正确
        bool res = nickname_check(new_nickname);
        if (res == false) {
            LOG_ERROR("用户名格式不合法！- {}-{}", new_nickname, new_nickname.size());
            return err_response(request->request_id(), "用户名格式不合法！");
        }

        // 3. 从数据库通过用户 ID 进行用户信息查询，判断用户是否存在
        auto user = _mysql_user->select_by_uid(uid);
        if (!user) {
            LOG_ERROR("未找到用户信息！- {}", uid);
            return err_response(request->request_id(), "未找到用户信息!");
        }

        // 4. 将新的昵称更新到数据库中
        user->nickname(new_nickname);
        res = _mysql_user->update(user);
        if (res == false) {
            LOG_ERROR("更新数据库用户昵称失败！- {}", new_nickname);
            return err_response(request->request_id(), "更新数据库用户昵称失败!");
        }

        // 5. 更新 ES 服务器中用户信息
        res = _es_user->appendData(user->user_id(), user->phone(), user->nickname(), user->description(), user->avatar_id());
        if (res == false) {
            LOG_ERROR("更新搜索引擎用户昵称失败！- {}",new_nickname);
            return err_response(request->request_id(), "更新搜索引擎用户昵称失败!");
        }

        // 6. 组织响应，返回更新成功与否
        response->set_request_id(request->request_id());
        response->set_success(true);  
    }

    virtual void SetUserDescription(::google::protobuf::RpcController* controller,
                        const ::suye::SetUserDescriptionReq* request,
                        ::suye::SetUserDescriptionRsp* response,
                        ::google::protobuf::Closure* done)
    {
        LOG_DEBUG("收到用户签名修改请求！");
        brpc::ClosureGuard rpc_guard(done);

        // 定义一个错误处理函数，当出错的时候被调用
        auto err_response = [this, response](const std::string& rid, 
            const std::string& errmsg) -> void {
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
                return;
            };

        // 1. 从请求中取出用户 ID 与新的昵称
        std::string uid = request->user_id();
        std::string new_description = request->description();

        // 2. 从数据库通过用户 ID 进行用户信息查询，判断用户是否存在
        auto user = _mysql_user->select_by_uid(uid);
        if (!user) {
            LOG_ERROR("未找到用户信息！- {}", uid);
            return err_response(request->request_id(), "未找到用户信息!");
        }

        // 3. 将新的昵称更新到数据库中
        user->description(new_description);
        bool res = _mysql_user->update(user);
        if (res == false) {
            LOG_ERROR("更新数据库用户签名失败！- {}", new_description);
            return err_response(request->request_id(), "更新数据库用户签名失败!");
        }

        // 4. 更新 ES 服务器中用户信息
        res = _es_user->appendData(user->user_id(), user->phone(), user->nickname(), user->description(), user->avatar_id());
        if (res == false) {
            LOG_ERROR("更新搜索引擎用户签名失败！- {}", new_description);
            return err_response(request->request_id(), "更新搜索引擎用户签名失败!");
        }

        // 5. 组织响应，返回更新成功与否
        response->set_request_id(request->request_id());
        response->set_success(true);
    }

    virtual void SetUserPhoneNumber(::google::protobuf::RpcController* controller,
                        const ::suye::SetUserPhoneNumberReq* request,
                        ::suye::SetUserPhoneNumberRsp* response,
                        ::google::protobuf::Closure* done)
    {
        LOG_DEBUG("收到用户手机号设置请求！");
        brpc::ClosureGuard rpc_guard(done);

        // 定义一个错误处理函数，当出错的时候被调用
        auto err_response = [this, response](const std::string& rid, 
            const std::string& errmsg) -> void {
                response->set_request_id(rid);
                response->set_success(false);
                response->set_errmsg(errmsg);
                return;
            };

        // 1. 从请求中取出用户 ID 与新的手机号
        std::string uid = request->user_id();
        std::string new_phone = request->phone_number();
        std::string code = request->phone_verify_code();
        std::string code_id = request->phone_verify_code_id();

        // 2. 对验证码进行验证
        auto vcode = _redis_codes->code(code_id);
        if (vcode != code) {
            LOG_ERROR("验证码错误！- {}-{}", code_id, code);
            return err_response(request->request_id(), "验证码错误!");
        }

        // 3. 从数据库通过用户 ID 进行用户信息查询，判断用户是否存在
        auto user = _mysql_user->select_by_uid(uid);
        if (!user) {
            LOG_ERROR("未找到用户信息！- {}", uid);
            return err_response(request->request_id(), "未找到用户信息!");
        }

        // 4. 将新的手机号更新到数据库中
        user->phone(new_phone);
        bool res = _mysql_user->update(user);
        if (res == false) {
            LOG_ERROR("更新数据库用户手机号失败！- {}", new_phone);
            return err_response(request->request_id(), "更新数据库用户手机号失败!");
        }

        // 5. 更新 ES 服务器中用户信息
        res = _es_user->appendData(user->user_id(), user->phone(), user->nickname(), user->description(), user->avatar_id());
        if (res == false) {
            LOG_ERROR("更新搜索引擎用户手机号失败！- {}", new_phone);
            return err_response(request->request_id(), "更新搜索引擎用户手机号失败!");
        }

        // 6. 组织响应，返回更新成功与否
        response->set_request_id(request->request_id());
        response->set_success(true);
    }

private:
    ESUser::ptr _es_user; 
    UserTable::ptr _mysql_user; 
    OutboxTable::ptr _mysql_outbox;
    Session::ptr _redis_session;
    Status::ptr _redis_status;
    Codes::ptr _redis_codes;
    // rpc调用客户端相关对象
    std::string _file_service_name;
    std::shared_ptr<ServiceManager> _sm_channels;
};

class UserServer {
public:
    using ptr = std::shared_ptr<UserServer>;
    UserServer(const Discovery::ptr service_discoverer, 
            const Registry::ptr& reg_client,
            const std::shared_ptr<elasticlient::Client>& es_client,
            const std::shared_ptr<odb::core::database>& mysql_client,
            std::shared_ptr<sw::redis::Redis>& redis_client,
            const std::shared_ptr<brpc::Server>& server,
            const UserOutboxDispatcher::ptr& outbox_dispatcher)
        : _service_discoverer(service_discoverer)
        , _registry_client(reg_client)
        , _es_client(es_client)
        , _mysql_client(mysql_client)
        , _redis_client(redis_client)
        , _rpc_server(server)
        , _outbox_dispatcher(outbox_dispatcher) {}

    ~UserServer()
    {
        if (_outbox_dispatcher)
        {
            _outbox_dispatcher->stop();
        }
    }
    
    // 搭建RPC服务器，并启动服务器
    void start()
    {
        if (_outbox_dispatcher)
        {
            _outbox_dispatcher->start();
            LOG_INFO("Outbox 同步任务已启动");
        }
        _rpc_server->RunUntilAskedToQuit();
    }

private:
    Discovery::ptr _service_discoverer;
    Registry::ptr _registry_client;
    std::shared_ptr<elasticlient::Client> _es_client;
    std::shared_ptr<odb::core::database> _mysql_client;
    std::shared_ptr<sw::redis::Redis> _redis_client;
    std::shared_ptr<brpc::Server> _rpc_server;
    UserOutboxDispatcher::ptr _outbox_dispatcher;
};

class UserServerBuilder {
public:
    //构造es客户端对象
    void make_es_object(const std::vector<std::string> host_list) 
    {
        _es_client = ESClientFactory::create(host_list);
    }

    //构造mysql客户端对象
    void make_mysql_object(
        const std::string& user,
        const std::string& pswd,
        const std::string& db,
        const std::string& host,
        const std::string& cset,
        int port,
        int conn_pool_count) 
    {
        _mysql_client = ODBFactory::create(user, pswd, db, host, cset, port, conn_pool_count);
    }

    //构造redis客户端对象
    void make_redis_object(const std::string& host,
        int port,
        int db,
        bool keep_alive) 
    {
        _redis_client = RedisClientFactory::create(host, port, db, keep_alive);
    }

    //用于构造服务发现客户端&信道管理对象
    void make_discovery_object(const std::string& reg_host,
                const std::string& base_service_name,
                const std::string& file_service_name) 
    {
        _file_service_name = file_service_name;
        _sm_channels = std::make_shared<ServiceManager>();
        _sm_channels->Declared(file_service_name);
        LOG_DEBUG("设置文件子服务为需添加管理的子服务：{}", file_service_name);
        auto put_cb = std::bind(&ServiceManager::OnServiceOnline, _sm_channels.get(), std::placeholders::_1, std::placeholders::_2);
        auto del_cb = std::bind(&ServiceManager::OnServiceOffline, _sm_channels.get(), std::placeholders::_1, std::placeholders::_2);
        _service_discoverer = std::make_shared<Discovery>(reg_host, base_service_name, put_cb, del_cb);
    }

    // 构造服务注册客户端对象
    void make_registry_object(const std::string& reg_host, 
                const std::string& service_name,
                const std::string& access_host)
    {
        _registry_client = std::make_shared<Registry>(reg_host);
        _registry_client->registry(service_name, access_host);
    }

    void make_rpc_server(uint16_t port, int32_t timeout, uint8_t num_threads) 
    {
        if (!_es_client) {
            LOG_ERROR("还未初始化ES搜索引擎模块！");
            abort();
        }
        if (!_mysql_client) {
            LOG_ERROR("还未初始化Mysql数据库模块！");
            abort();
        }
        if (!_redis_client) {
            LOG_ERROR("还未初始化Redis数据库模块！");
            abort();
        }
        if (!_sm_channels) {
            LOG_ERROR("还未初始化信道管理模块！");
            abort();
        }
        _rpc_server = std::make_shared<brpc::Server>();

        UserServiceImpl *user_service = new UserServiceImpl(_es_client,
            _mysql_client, _redis_client, _sm_channels, _file_service_name);
        int res = _rpc_server->AddService(user_service, brpc::ServiceOwnership::SERVER_OWNS_SERVICE);
        if (res == -1) {
            LOG_ERROR("添加Rpc服务失败！");
            abort();
        }
        brpc::ServerOptions options;
        options.idle_timeout_sec = timeout;
        options.num_threads = num_threads;
        res = _rpc_server->Start(port,& options);
        if (res == -1) {
            LOG_ERROR("服务启动失败！");
            abort();
        }
    }

    void make_outbox_dispatcher()
    {
        if (!_mysql_client)
        {
            LOG_ERROR("还未初始化Mysql数据库模块，无法创建 Outbox Dispatcher！");
            abort();
        }
        if (!_es_client)
        {
            LOG_ERROR("还未初始化ES搜索引擎模块，无法创建 Outbox Dispatcher！");
            abort();
        }
        if (!_redis_client)
        {
            LOG_ERROR("还未初始化Redis数据库模块，无法创建 Outbox Dispatcher！");
            abort();
        }

        auto outbox_table = std::make_shared<OutboxTable>(_mysql_client);
        auto es_user = std::make_shared<ESUser>(_es_client);
        auto cache_service = std::make_shared<CacheService>(_redis_client, std::chrono::seconds(1800));

        _outbox_dispatcher = std::make_shared<UserOutboxDispatcher>(outbox_table, es_user, cache_service);
        LOG_INFO("Outbox Dispatcher 初始化成功");
    }

    //构造RPC服务器对象
    UserServer::ptr build() 
    {
        if (!_service_discoverer) {
            LOG_ERROR("还未初始化服务发现模块！");
            abort();
        }
        if (!_registry_client) {
            LOG_ERROR("还未初始化服务注册模块！");
            abort();
        }
        if (!_rpc_server) {
            LOG_ERROR("还未初始化RPC服务器模块！");
            abort();
        }

        if (!_outbox_dispatcher)
        {
            make_outbox_dispatcher();
        }

        UserServer::ptr server = std::make_shared<UserServer>(
            _service_discoverer, _registry_client,
            _es_client, _mysql_client, _redis_client, _rpc_server, _outbox_dispatcher);
        return server;
    }

private:
    Registry::ptr _registry_client;

    std::shared_ptr<elasticlient::Client> _es_client;
    std::shared_ptr<odb::core::database> _mysql_client;
    std::shared_ptr<sw::redis::Redis> _redis_client;

    std::string _file_service_name;
    ServiceManager::ptr _sm_channels;
    Discovery::ptr _service_discoverer;

    std::shared_ptr<brpc::Server> _rpc_server;
    UserOutboxDispatcher::ptr _outbox_dispatcher;
};
}